package org.simpleframework.util;

import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.FileFilter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;

/**
 * @program: simpleframework
 * @description:
 * @author: lishuang
 * @create: 2021-11-23 13:44
 **/
@Slf4j
public class ClassUtil {
    public static final String  FILE_PROTOCOL="file";

    /**
     * 获取包下所有类
     * 通过类加载器获取类
     * @param packageName
     * @return
     */
    public static Set<Class<?>> extractPackageClass(String packageName) {
        //1 获取类加载器
        ClassLoader classLoader = getClassLoader();
        //2 通过类加载器获取加载的资源
        URL url = classLoader.getResource(packageName.replace(".", "/"));
        if (url==null){
            log.warn("unable to retrieve anything from package:"+packageName);
            return null;
        }
        //3 依据不同的资源类型，采用不同的方式获取资源的集合
        Set<Class<?>> classSet = null;
        if (url.getProtocol().equalsIgnoreCase(FILE_PROTOCOL)){
            classSet = new HashSet<>();
            File packageDirectory = new File(url.getPath());
            extractClassFile(classSet,packageDirectory,packageName);
        }
        return classSet;
    }

    /**
     * 递归获取目标package里面所有class文件
     * @param emptyClassSet
     * @param source   文件或目录
     * @param packageName 包名
     */
    private static void extractClassFile(Set<Class<?>> emptyClassSet, File source, String packageName) {
        if (!source.isDirectory()){
            return;
        }
        //如果是文件夹，调用listFiles()获取文件夹的所有子文件
        File[] files = source.listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                if (file.isDirectory()){
                    return true;
                }else {
                    //获取文件的绝对路径
                    String absolutePath = file.getAbsolutePath();
                    if (absolutePath.endsWith(".class")){
                        //若是class文件，直接加载
                        addToClassSet(absolutePath);
                    }
                }
                return false;
            }
            private void addToClassSet(String absolutePath) {
                //1.从class文件的绝对值路径里提取出包含了package的类名
                //需要弄成com.ls.entity.dto.MainPageInfoDTO
                absolutePath = absolutePath.replace(File.separator, ".");
                String className = absolutePath.substring(absolutePath.indexOf(packageName));
                //去掉.class后缀
                className = className.substring(0, className.lastIndexOf("."));
                //2.通过反射机制获取对应的Class对象并加入到classSet里
                Class targetClass = loadClass(className);
                emptyClassSet.add(targetClass);
            }
        });
        if (files!=null){
            for (File file : files) {
                //递归调用
                extractClassFile(emptyClassSet, file, packageName);
            }
        }
    }

    /**
     * 获取Class对象
     *
     * @param className class全名=package + 类名
     * @return Class
     */
    public static Class<?> loadClass(String className){
        try {
            return Class.forName(className);
        } catch (ClassNotFoundException e) {
            System.out.println("load class error:"+ e);
            throw new RuntimeException(e);
        }
    }
    /**
     * 获取classLoader
     * @return
     */
    public static ClassLoader getClassLoader(){
        return Thread.currentThread().getContextClassLoader();
    }

    /**
     * 实例化class
     *
     * @param clazz Class
     * @param <T>   class的类型
     * @param accessible   是否支持创建出私有class对象的实例
     * @return 类的实例化
     */
    public static <T> T newInstance(Class<?> clazz, boolean accessible){
        try {
            Constructor constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(accessible);
            return (T)constructor.newInstance();
        } catch (Exception e) {
            log.error("newInstance error", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 设置类的属性值
     *
     * @param field      成员变量
     * @param fieldClass     类实例
     * @param fieldValue      成员变量的值
     * @param accessible 是否允许设置私有属性
     */
    public static void setField(Field field, Object fieldClass, Object fieldValue, boolean accessible) {
        field.setAccessible(accessible);
        try {

            /**
             * Field.set(obj,value)
             * obj – 应修改其字段的对象(理解为被修改的对象）
             * value – 正在修改的obj字段的新值（被修改对象对应字段的新值）
             */
            field.set(fieldClass, fieldValue);
        } catch (IllegalAccessException e) {
            log.error("setField error", e);
            throw new RuntimeException(e);
        }
    }
}
